/*
 * Ext JS Library 0.20 Copyright(c) 2006-2008, Ext JS, LLC. licensing@extjs.com
 * 
 * http://extjs.com/license
 */

/*
 * This file corrects air eval issues and other issues found in the AIR
 * application sandbox
 */
Ext.namespace('Ext.air', 'Ext.sql');

Ext.Template.prototype.compile = function() {
	var fm = Ext.util.Format;
	var useF = this.disableFormats !== true;
	//
	var prevOffset = 0;
	var arr = [];
	var tpl = this;
	var fn = function(m, name, format, args, offset, s) {
		if (prevOffset != offset) {
			var action = {
				type : 1,
				value : s.substr(prevOffset, offset - prevOffset)
			};
			arr.push(action);
		}
		prevOffset = offset + m.length;
		if (format && useF) {
			if (args) {
				var re = /^\s*['"](.*)["']\s*$/;
				args = args.split(/,(?=(?:[^"]*"[^"]*")*(?![^"]*"))/);
				for (var i = 0, len = args.length; i < len; i++) {
					args[i] = args[i].replace(re, "$1");
				}
				args = [''].concat(args);
			} else {
				args = [''];
			}
			if (format.substr(0, 5) != "this.") {
				var action = {
					type : 3,
					value : name,
					format : fm[format],
					args : args,
					scope : fm
				};
				arr.push(action);
			} else {
				var action = {
					type : 3,
					value : name,
					format : tpl[format.substr(5)],
					args : args,
					scope : tpl
				};
				arr.push(action);
			}
		} else {
			var action = {
				type : 2,
				value : name
			};
			arr.push(action);
		}
		return m;
	};

	var s = this.html.replace(this.re, fn);
	if (prevOffset != (s.length - 1)) {
		var action = {
			type : 1,
			value : s.substr(prevOffset, s.length - prevOffset)
		};
		arr.push(action);
	}

	this.compiled = function(values) {
		function applyValues(el) {
			switch (el.type) {
				case 1 :
					return el.value;
				case 2 :
					return (values[el.value] ? values[el.value] : '');
				default :
					el.args[0] = values[el.value];
					return el.format.apply(el.scope, el.args);
			}
		}
		return arr.map(applyValues).join('');
	}
	return this;
};

Ext.Template.prototype.call = function(fnName, value, allValues) {
	return this[fnName](value, allValues);
}

Ext.DomQuery = function() {
	var cache = {}, simpleCache = {}, valueCache = {};
	var nonSpace = /\S/;
	var trimRe = /^\s+|\s+$/g;
	var tplRe = /\{(\d+)\}/g;
	var modeRe = /^(\s?[\/>+~]\s?|\s|$)/;
	var tagTokenRe = /^(#)?([\w-\*]+)/;
	var nthRe = /(\d*)n\+?(\d*)/, nthRe2 = /\D/;

	function child(p, index) {
		var i = 0;
		var n = p.firstChild;
		while (n) {
			if (n.nodeType == 1) {
				if (++i == index) {
					return n;
				}
			}
			n = n.nextSibling;
		}
		return null;
	};

	function next(n) {
		while ((n = n.nextSibling) && n.nodeType != 1);
		return n;
	};

	function prev(n) {
		while ((n = n.previousSibling) && n.nodeType != 1);
		return n;
	};

	function children(d) {
		var n = d.firstChild, ni = -1;
		while (n) {
			var nx = n.nextSibling;
			if (n.nodeType == 3 && !nonSpace.test(n.nodeValue)) {
				d.removeChild(n);
			} else {
				n.nodeIndex = ++ni;
			}
			n = nx;
		}
		return this;
	};

	function byClassName(c, a, v) {
		if (!v) {
			return c;
		}
		var r = [], ri = -1, cn;
		for (var i = 0, ci; ci = c[i]; i++) {
			if ((' ' + ci.className + ' ').indexOf(v) != -1) {
				r[++ri] = ci;
			}
		}
		return r;
	};

	function attrValue(n, attr) {
		if (!n.tagName && typeof n.length != "undefined") {
			n = n[0];
		}
		if (!n) {
			return null;
		}
		if (attr == "for") {
			return n.htmlFor;
		}
		if (attr == "class" || attr == "className") {
			return n.className;
		}
		return n.getAttribute(attr) || n[attr];

	};

	function getNodes(ns, mode, tagName) {
		var result = [], ri = -1, cs;
		if (!ns) {
			return result;
		}
		tagName = tagName || "*";
		if (typeof ns.getElementsByTagName != "undefined") {
			ns = [ns];
		}
		if (!mode) {
			for (var i = 0, ni; ni = ns[i]; i++) {
				cs = ni.getElementsByTagName(tagName);
				for (var j = 0, ci; ci = cs[j]; j++) {
					result[++ri] = ci;
				}
			}
		} else if (mode == "/" || mode == ">") {
			var utag = tagName.toUpperCase();
			for (var i = 0, ni, cn; ni = ns[i]; i++) {
				cn = ni.children || ni.childNodes;
				for (var j = 0, cj; cj = cn[j]; j++) {
					if (cj.nodeName == utag || cj.nodeName == tagName
							|| tagName == '*') {
						result[++ri] = cj;
					}
				}
			}
		} else if (mode == "+") {
			var utag = tagName.toUpperCase();
			for (var i = 0, n; n = ns[i]; i++) {
				while ((n = n.nextSibling) && n.nodeType != 1);
				if (n
						&& (n.nodeName == utag || n.nodeName == tagName || tagName == '*')) {
					result[++ri] = n;
				}
			}
		} else if (mode == "~") {
			for (var i = 0, n; n = ns[i]; i++) {
				while ((n = n.nextSibling)
						&& (n.nodeType != 1 || (tagName == '*' || n.tagName
								.toLowerCase() != tagName)));
				if (n) {
					result[++ri] = n;
				}
			}
		}
		return result;
	};

	function concat(a, b) {
		if (b.slice) {
			return a.concat(b);
		}
		for (var i = 0, l = b.length; i < l; i++) {
			a[a.length] = b[i];
		}
		return a;
	}

	function byTag(cs, tagName) {
		if (cs.tagName || cs == document) {
			cs = [cs];
		}
		if (!tagName) {
			return cs;
		}
		var r = [], ri = -1;
		tagName = tagName.toLowerCase();
		for (var i = 0, ci; ci = cs[i]; i++) {
			if (ci.nodeType == 1 && ci.tagName.toLowerCase() == tagName) {
				r[++ri] = ci;
			}
		}
		return r;
	};

	function byId(cs, attr, id) {
		if (cs.tagName || cs == document) {
			cs = [cs];
		}
		if (!id) {
			return cs;
		}
		var r = [], ri = -1;
		for (var i = 0, ci; ci = cs[i]; i++) {
			if (ci && ci.id == id) {
				r[++ri] = ci;
				return r;
			}
		}
		return r;
	};

	function byAttribute(cs, attr, value, op, custom) {
		var r = [], ri = -1, st = custom == "{";
		var f = Ext.DomQuery.operators[op];
		for (var i = 0, ci; ci = cs[i]; i++) {
			var a;
			if (st) {
				a = Ext.DomQuery.getStyle(ci, attr);
			} else if (attr == "class" || attr == "className") {
				a = ci.className;
			} else if (attr == "for") {
				a = ci.htmlFor;
			} else if (attr == "href") {
				a = ci.getAttribute("href", 2);
			} else {
				a = ci.getAttribute(attr);
			}
			if ((f && f(a, value)) || (!f && a)) {
				r[++ri] = ci;
			}
		}
		return r;
	};

	function byPseudo(cs, name, value) {
		return Ext.DomQuery.pseudos[name](cs, value);
	};

	// this eval is stop the compressor from
	// renaming the variable to something shorter
	eval("var batch = 30803;");

	var key = 30803;

	function nodup(cs) {
		if (!cs) {
			return [];
		}
		var len = cs.length, c, i, r = cs, cj, ri = -1;
		if (!len || typeof cs.nodeType != "undefined" || len == 1) {
			return cs;
		}
		var d = ++key;
		cs[0]._nodup = d;
		for (i = 1; c = cs[i]; i++) {
			if (c._nodup != d) {
				c._nodup = d;
			} else {
				r = [];
				for (var j = 0; j < i; j++) {
					r[++ri] = cs[j];
				}
				for (j = i + 1; cj = cs[j]; j++) {
					if (cj._nodup != d) {
						cj._nodup = d;
						r[++ri] = cj;
					}
				}
				return r;
			}
		}
		return r;
	}

	function quickDiff(c1, c2) {
		var len1 = c1.length;
		if (!len1) {
			return c2;
		}
		var d = ++key;
		for (var i = 0; i < len1; i++) {
			c1[i]._qdiff = d;
		}
		var r = [];
		for (var i = 0, len = c2.length; i < len; i++) {
			if (c2[i]._qdiff != d) {
				r[r.length] = c2[i];
			}
		}
		return r;
	}

	function quickId(ns, mode, root, id) {
		if (ns == root) {
			var d = root.ownerDocument || root;
			return d.getElementById(id);
		}
		ns = getNodes(ns, mode, "*");
		return byId(ns, null, id);
	}

	function search(path, root, type) {
		type = type || "select";
		//
		var n = root || document;
		//
		var q = path, mode, lq;
		var tk = Ext.DomQuery.matchers;
		var tklen = tk.length;
		var mm;

		var lmode = q.match(modeRe);
		if (lmode && lmode[1]) {
			mode = lmode[1].replace(trimRe, "");
			q = q.replace(lmode[1], "");
		}
		while (path.substr(0, 1) == "/") {
			path = path.substr(1);
		}
		while (q && lq != q) {
			lq = q;
			var tm = q.match(tagTokenRe);
			if (type == "select") {
				if (tm) {
					if (tm[1] == "#") {
						n = quickId(n, mode, root, tm[2]);
					} else {
						n = getNodes(n, mode, tm[2]);
					}
					q = q.replace(tm[0], "");
				} else if (q.substr(0, 1) != '@') {
					n = getNodes(n, mode, "*");
				}
			} else {
				if (tm) {
					if (tm[1] == "#") {
						n = byId(n, null, tm[2]);
					} else {
						n = byTag(n, tm[2]);
					}
					q = q.replace(tm[0], "");
				}
			}
			while (!(mm = q.match(modeRe))) {
				var matched = false;
				for (var j = 0; j < tklen; j++) {
					var t = tk[j];
					var m = q.match(t.re);
					if (m) {
						switch (j) {
							case 0 :
								n = byClassName(n, null, " " + m[1] + " ");
								break;
							case 1 :
								n = byPseudo(n, m[1], m[2]);
								break;
							case 2 :
								n = byAttribute(n, m[2], m[4], m[3], m[1]);
								break;
							case 3 :
								n = byId(n, null, m[1]);
								break;
							case 4 :
								return {
									firstChild : {
										nodeValue : attrValue(n, m[1])
									}
								};

						}
						q = q.replace(m[0], "");
						matched = true;
						break;
					}
				}

				if (!matched) {
					throw 'Error parsing selector, parsing failed at "' + q
							+ '"';
				}
			}
			if (mm[1]) {
				mode = mm[1].replace(trimRe, "");
				q = q.replace(mm[1], "");
			}
		}
		return nodup(n);
	}

	return {
		getStyle : function(el, name) {
			return Ext.fly(el).getStyle(name);
		},

		compile : function(path, type) {
			return function(root) {
				return search(path, root, type);
			}
		},

		/**
		 * Selects a group of elements.
		 * 
		 * @param {String}
		 *            selector The selector/xpath query (can be a comma
		 *            separated list of selectors)
		 * @param {Node}
		 *            root (optional) The start of the query (defaults to
		 *            document).
		 * @return {Array}
		 */
		select : function(path, root, type) {
			if (!root || root == document) {
				root = document;
			}
			if (typeof root == "string") {
				root = document.getElementById(root);
			}
			var paths = path.split(",");
			var results = [];
			for (var i = 0, len = paths.length; i < len; i++) {
				var p = paths[i].replace(trimRe, "");
				if (!cache[p]) {
					cache[p] = Ext.DomQuery.compile(p);
					if (!cache[p]) {
						throw p + " is not a valid selector";
					}
				}
				var result = cache[p](root);
				if (result && result != document) {
					results = results.concat(result);
				}
			}
			if (paths.length > 1) {
				return nodup(results);
			}
			return results;
		},

		/**
		 * Selects a single element.
		 * 
		 * @param {String}
		 *            selector The selector/xpath query
		 * @param {Node}
		 *            root (optional) The start of the query (defaults to
		 *            document).
		 * @return {Element}
		 */
		selectNode : function(path, root) {
			return Ext.DomQuery.select(path, root)[0];
		},

		/**
		 * Selects the value of a node, optionally replacing null with the
		 * defaultValue.
		 * 
		 * @param {String}
		 *            selector The selector/xpath query
		 * @param {Node}
		 *            root (optional) The start of the query (defaults to
		 *            document).
		 * @param {String}
		 *            defaultValue
		 */
		selectValue : function(path, root, defaultValue) {
			path = path.replace(trimRe, "");
			if (!valueCache[path]) {
				valueCache[path] = Ext.DomQuery.compile(path, "select");
			}
			var n = valueCache[path](root);
			n = n[0] ? n[0] : n;
			var v = (n && n.firstChild ? n.firstChild.nodeValue : null);
			return ((v === null || v === undefined || v === '')
					? defaultValue
					: v);
		},

		/**
		 * Selects the value of a node, parsing integers and floats.
		 * 
		 * @param {String}
		 *            selector The selector/xpath query
		 * @param {Node}
		 *            root (optional) The start of the query (defaults to
		 *            document).
		 * @param {Number}
		 *            defaultValue
		 * @return {Number}
		 */
		selectNumber : function(path, root, defaultValue) {
			var v = Ext.DomQuery.selectValue(path, root, defaultValue || 0);
			return parseFloat(v);
		},

		/**
		 * Returns true if the passed element(s) match the passed simple
		 * selector (e.g. div.some-class or span:first-child)
		 * 
		 * @param {String/HTMLElement/Array}
		 *            el An element id, element or array of elements
		 * @param {String}
		 *            selector The simple selector to test
		 * @return {Boolean}
		 */
		is : function(el, ss) {
			if (typeof el == "string") {
				el = document.getElementById(el);
			}
			var isArray = Ext.isArray(el);
			var result = Ext.DomQuery.filter(isArray ? el : [el], ss);
			return isArray ? (result.length == el.length) : (result.length > 0);
		},

		/**
		 * Filters an array of elements to only include matches of a simple
		 * selector (e.g. div.some-class or span:first-child)
		 * 
		 * @param {Array}
		 *            el An array of elements to filter
		 * @param {String}
		 *            selector The simple selector to test
		 * @param {Boolean}
		 *            nonMatches If true, it returns the elements that DON'T
		 *            match the selector instead of the ones that match
		 * @return {Array}
		 */
		filter : function(els, ss, nonMatches) {
			ss = ss.replace(trimRe, "");
			if (!simpleCache[ss]) {
				simpleCache[ss] = Ext.DomQuery.compile(ss, "simple");
			}
			var result = simpleCache[ss](els);
			return nonMatches ? quickDiff(result, els) : result;
		},

		/**
		 * Collection of matching regular expressions and code snippets.
		 */
		matchers : [{
					re : /^\.([\w-]+)/,
					select : 'n = byClassName(n, null, " {1} ");'
				}, {
					re : /^\:([\w-]+)(?:\(((?:[^\s>\/]*|.*?))\))?/,
					select : 'n = byPseudo(n, "{1}", "{2}");'
				}, {
					re : /^(?:([\[\{])(?:@)?([\w-]+)\s?(?:(=|.=)\s?['"]?(.*?)["']?)?[\]\}])/,
					select : 'n = byAttribute(n, "{2}", "{4}", "{3}", "{1}");'
				}, {
					re : /^#([\w-]+)/,
					select : 'n = byId(n, null, "{1}");'
				}, {
					re : /^@([\w-]+)/,
					select : 'return {firstChild:{nodeValue:attrValue(n, "{1}")}};'
				}],

		/**
		 * Collection of operator comparison functions. The default operators
		 * are =, !=, ^=, $=, *=, %=, |= and ~=. New operators can be added as
		 * long as the match the format <i>c</i>= where <i>c</i> is any
		 * character other than space, &gt; &lt;.
		 */
		operators : {
			"=" : function(a, v) {
				return a == v;
			},
			"!=" : function(a, v) {
				return a != v;
			},
			"^=" : function(a, v) {
				return a && a.substr(0, v.length) == v;
			},
			"$=" : function(a, v) {
				return a && a.substr(a.length - v.length) == v;
			},
			"*=" : function(a, v) {
				return a && a.indexOf(v) !== -1;
			},
			"%=" : function(a, v) {
				return (a % v) == 0;
			},
			"|=" : function(a, v) {
				return a && (a == v || a.substr(0, v.length + 1) == v + '-');
			},
			"~=" : function(a, v) {
				return a && (' ' + a + ' ').indexOf(' ' + v + ' ') != -1;
			}
		},

		/**
		 * Collection of "pseudo class" processors. Each processor is passed the
		 * current nodeset (array) and the argument (if any) supplied in the
		 * selector.
		 */
		pseudos : {
			"first-child" : function(c) {
				var r = [], ri = -1, n;
				for (var i = 0, ci; ci = n = c[i]; i++) {
					while ((n = n.previousSibling) && n.nodeType != 1);
					if (!n) {
						r[++ri] = ci;
					}
				}
				return r;
			},

			"last-child" : function(c) {
				var r = [], ri = -1, n;
				for (var i = 0, ci; ci = n = c[i]; i++) {
					while ((n = n.nextSibling) && n.nodeType != 1);
					if (!n) {
						r[++ri] = ci;
					}
				}
				return r;
			},

			"nth-child" : function(c, a) {
				var r = [], ri = -1;
				var m = nthRe.exec(a == "even" && "2n" || a == "odd" && "2n+1"
						|| !nthRe2.test(a) && "n+" + a || a);
				var f = (m[1] || 1) - 0, l = m[2] - 0;
				for (var i = 0, n; n = c[i]; i++) {
					var pn = n.parentNode;
					if (batch != pn._batch) {
						var j = 0;
						for (var cn = pn.firstChild; cn; cn = cn.nextSibling) {
							if (cn.nodeType == 1) {
								cn.nodeIndex = ++j;
							}
						}
						pn._batch = batch;
					}
					if (f == 1) {
						if (l == 0 || n.nodeIndex == l) {
							r[++ri] = n;
						}
					} else if ((n.nodeIndex + l) % f == 0) {
						r[++ri] = n;
					}
				}

				return r;
			},

			"only-child" : function(c) {
				var r = [], ri = -1;;
				for (var i = 0, ci; ci = c[i]; i++) {
					if (!prev(ci) && !next(ci)) {
						r[++ri] = ci;
					}
				}
				return r;
			},

			"empty" : function(c) {
				var r = [], ri = -1;
				for (var i = 0, ci; ci = c[i]; i++) {
					var cns = ci.childNodes, j = 0, cn, empty = true;
					while (cn = cns[j]) {
						++j;
						if (cn.nodeType == 1 || cn.nodeType == 3) {
							empty = false;
							break;
						}
					}
					if (empty) {
						r[++ri] = ci;
					}
				}
				return r;
			},

			"contains" : function(c, v) {
				var r = [], ri = -1;
				for (var i = 0, ci; ci = c[i]; i++) {
					if ((ci.textContent || ci.innerText || '').indexOf(v) != -1) {
						r[++ri] = ci;
					}
				}
				return r;
			},

			"nodeValue" : function(c, v) {
				var r = [], ri = -1;
				for (var i = 0, ci; ci = c[i]; i++) {
					if (ci.firstChild && ci.firstChild.nodeValue == v) {
						r[++ri] = ci;
					}
				}
				return r;
			},

			"checked" : function(c) {
				var r = [], ri = -1;
				for (var i = 0, ci; ci = c[i]; i++) {
					if (ci.checked == true) {
						r[++ri] = ci;
					}
				}
				return r;
			},

			"not" : function(c, ss) {
				return Ext.DomQuery.filter(c, ss, true);
			},

			"any" : function(c, selectors) {
				var ss = selectors.split('|');
				var r = [], ri = -1, s;
				for (var i = 0, ci; ci = c[i]; i++) {
					for (var j = 0; s = ss[j]; j++) {
						if (Ext.DomQuery.is(ci, s)) {
							r[++ri] = ci;
							break;
						}
					}
				}
				return r;
			},

			"odd" : function(c) {
				return this["nth-child"](c, "odd");
			},

			"even" : function(c) {
				return this["nth-child"](c, "even");
			},

			"nth" : function(c, a) {
				return c[a - 1] || [];
			},

			"first" : function(c) {
				return c[0] || [];
			},

			"last" : function(c) {
				return c[c.length - 1] || [];
			},

			"has" : function(c, ss) {
				var s = Ext.DomQuery.select;
				var r = [], ri = -1;
				for (var i = 0, ci; ci = c[i]; i++) {
					if (s(ss, ci).length > 0) {
						r[++ri] = ci;
					}
				}
				return r;
			},

			"next" : function(c, ss) {
				var is = Ext.DomQuery.is;
				var r = [], ri = -1;
				for (var i = 0, ci; ci = c[i]; i++) {
					var n = next(ci);
					if (n && is(n, ss)) {
						r[++ri] = ci;
					}
				}
				return r;
			},

			"prev" : function(c, ss) {
				var is = Ext.DomQuery.is;
				var r = [], ri = -1;
				for (var i = 0, ci; ci = c[i]; i++) {
					var n = prev(ci);
					if (n && is(n, ss)) {
						r[++ri] = ci;
					}
				}
				return r;
			}
		}
	};
}();

Ext.query = Ext.DomQuery.select;

Date.precompileFormats = function(s) {
	var formats = s.split('|');
	for (var i = 0, len = formats.length; i < len; i++) {
		Date.createNewFormat(formats[i]);
		Date.createParser(formats[i]);
	}
}

Date
		.precompileFormats("D n/j/Y|n/j/Y|n/j/y|m/j/y|n/d/y|m/j/Y|n/d/Y|YmdHis|F d, Y|l, F d, Y|H:i:s|g:i A|g:ia|g:iA|g:i a|g:i A|h:i|g:i|H:i|ga|ha|gA|h a|g a|g A|gi|hi|gia|hia|g|H|m/d/y|m/d/Y|m-d-y|m-d-Y|m/d|m-d|md|mdy|mdY|d|Y-m-d|Y-m-d H:i:s|d/m/y|d/m/Y|d-m-y|d-m-Y|d/m|d-m|dm|dmy|dmY|Y-m-d|l|D m/d|D m/d/Y|m/d/Y");

// precompile instead of lazy init
Ext.ColorPalette.prototype.tpl = new Ext.XTemplate('<tpl for="."><a href="#" class="color-{.}" hidefocus="on"><em><span style="background:#{.}" unselectable="on">&#160;</span></em></a></tpl>');
